import Util from '../../model/util.js'
import axios from 'axios';
import {toast} from 'nc-lightapp-front';
import {OnDocumentAfterClose, OnDocumentBeforeClose} from './actions/wpsEventListenter';
import taskpane from '../taskpane/index.js';
/* global wps:false */
var WebNotifycount = 0;
//标识文档的落地模式 本地文档落地 0 ，不落地 1
const EnumDocLandMode = {
    DLM_LocalDoc: 0,
    DLM_OnlineDoc: 1
}
const EnumOAFlag = {
    DocFromOA: 1,
    DocFromNoOA: 0
}
/**
 * WPS上传文件到服务端（业务系统可根据实际情况进行修改，为了兼容中文，服务端约定用UTF-8编码格式）
 * @param {*} strFileName 上传到服务端的文件名称（包含文件后缀）
 * @param {*} strPath 上传文件的文件路径（文件在操作系统的绝对路径）
 * @param {*} uploadPath 上传文件的服务端地址
 * @param {*} otherData 传递平台定义需要的参数appcode key 等
 * @param {*} OnSuccess 上传成功后的回调
 * @param {*} OnFail 上传失败后的回调
 */
// function UploadFile(strFileName, strPath, uploadPath, otherData, OnSuccess, OnFail) {
//     // 	readFileString ,readAsBinaryString
//     var fileData = wps.FileSystem.readAsBinaryString(strPath);
//     let oriData = {
//         "busiParamJson":JSON.stringify({"file":fileData,"pk_rpt_def":window.pk_rpt_def,"upload":'true',"key":otherData.key,'appcode':otherData.appcode}),
//         "sysParamJson":{"busiaction":"wps-上传文件","appcode":otherData.appcode,"ts":window.cookiets || window.top.cookiets,"from":"","pagecs":window.cookiets || window.top.cookiets}
//     }
//     axios({
//         method:'post',
//         headers:{'content-type':'application/json;charset=UTF-8',
//                 "Cache-Control": "no-cache"},
//         url:uploadPath,
//         data: oriData,
//         withCredentials: true,
//     }).then((res)=>{
//         OnSuccess(res)
//     },(err)=>{
//         OnFail(err)
//     })
// }
function UploadFile(strFileName, strPath, uploadPath, otherData, OnSuccess, OnFail) {
    // 	readFileString ,readAsBinaryString
    var fileData = wps.FileSystem.readAsBinaryString(strPath);
    const FakeFormData = Util.FakeFormData 
    // var data = new FormData();
    var data = new FakeFormData()
    let pk_rpt_def = wps.PluginStorage.getItem(window.currentDocId + 'pk_rpt_def')
    let pk_conmodel = wps.PluginStorage.getItem(window.currentDocId + 'pk_conmodel')
    let oriData = {
        "upload":'true',
        // "pk_rpt_def":window.pk_conmodel?'':window.pk_rpt_def,
        // "pk_conmodel":window.pk_conmodel?window.pk_rpt_def:'',
        "pk_rpt_def":pk_conmodel?'':pk_rpt_def,
        "pk_conmodel":pk_conmodel?pk_rpt_def:'',
        ...otherData
    }
    let dataSucce = JSON.stringify(oriData)
    console.log('主要传输给系统的业务参数',dataSucce)
    console.log("上传的文件",fileData)
    let busiaction = "wps-上传文件";
    data.append('file', {
        name: strFileName, //主要是考虑中文名的情况，服务端约定用utf-8来解码。
        type: "application/octet-stream",
        getAsBinary: function () {
            return fileData;
        }
    });
    data.append('busiParamJson', dataSucce)
    data.append('sys_busiaction', busiaction)
    data.append('sys_appcode', otherData.appcode)
    data.append('sys_ts', new Date().getTime())
    // axios({
    //     method:'post',
    //     headers:{'Content-Type': 'multipart/form-data',
    //             "Cache-Control": "no-cache",
    //             "X-Requested-With": "XMLHttpRequest"},
    //     url:uploadPath,
    //     data: data,
    //     withCredentials: true,
    // }).then((res)=>{
    //     OnSuccess(res)
    // },(err)=>{
    //     OnFail(err)
    // })
    var xhr = new XMLHttpRequest();
    xhr.open('POST', uploadPath);
    xhr.onreadystatechange = function () {
        if (xhr.readyState == 4) {
            if (xhr.status == 200)
                OnSuccess(xhr.response)
            else
                OnFail(xhr.response);
        }
    };
    xhr.setRequestHeader("Cache-Control", "no-cache");
    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    xhr.setRequestHeader("Content-Type", "multipart/form-data; boundary=" + data.boundary);
    xhr.setRequestHeader('cookiets', window.cookiets || window.top.cookiets);
    xhr.send(data.toString());
}
/**
 * WPS下载文件到本地打开（业务系统可根据实际情况进行修改）
 * @param {*} url 文件流的下载路径
 * @param {*} callback 下载后的回调
 */
function DownloadFile(url,data,callback) {
    var xhr = new XMLHttpRequest();
    xhr.onreadystatechange = function () {
        if (this.readyState == 4 && this.status == 200) {
            //需要业务系统的服务端在传递文件流时，确保请求中的参数有filename
            //console 返回的参数
            console.log(xhr.response)
            var fileName = data.RptName + '.rtf'
            //落地打开模式下，WPS会将文件下载到本地的临时目录，在关闭后会进行清理
            // var path = wps.Env.GetTempPath() + "/" + fileName
            // Administrator
            var path = wps.Env.GetHomePath()+"\\Downloads"+"\\"+fileName
            var reader = new FileReader();
            reader.onload = function () {
                wps.FileSystem.writeAsBinaryString(path, reader.result);
                 callback(path);
            };
            reader.readAsBinaryString(xhr.response);
        }
    }
    xhr.open('POST', url);
    xhr.setRequestHeader('content-type','application/json;charset=UTF-8');
    xhr.setRequestHeader('cookiets', window.cookiets || window.top.cookiets);
    // "pk_rpt_def":"1001Z710000000000JB4"
    xhr.responseType = 'blob';
    let preData = {
        "key":data.key,'appcode':data.appcode,
        "pk_psnjob": data.pk_psnjob || '',
        'pk_psndoc':data.pk_psndoc || '',
        "pk_rpt_def":data.pk_conmodel?'':data.pk_rpt_def,
        "pk_conmodel":data.pk_conmodel?data.pk_conmodel:'',
        "pk_psndoc_sub": data.pk_psndoc_sub || '',
        "pk_agreement": data.pk_agreement || '',
        "pk_org": data.pk_org || '',
        "internalDataFactory": "nccloud.web.hrhi.rptdef.factory.RtfDownloadFactory"
    }
    let requestData = {
        "busiParamJson":JSON.stringify(preData),
        "sysParamJson":{"busiaction":"wps-获取文档","appcode":data.appcode,"ts":window.cookiets || window.top.cookiets,"from":"","pagecs":window.cookiets || window.top.cookiets, "cookiets": window.cookiets || window.top.cookiets}
    }
    xhr.send(JSON.stringify(requestData));
}





/**
 * 作用：文档打开后执行的动作集合
 * @param {*} doc 文档对象
 * @param {*} params 前端传递的参数集合
 * @param {*} isOnlineDoc 在线打开/落地打开
 */
function pOpenFile(doc, params, isOnlineDoc) {
    var l_IsOnlineDoc = isOnlineDoc
        //Office文件打开后，设置该文件属性：从服务端来的OA文件
    pSetOADocumentFlag(doc, params)
        //设置当前文档为 本地磁盘落地模式
    if (l_IsOnlineDoc == true) {
        DoSetOADocLandMode(doc, EnumDocLandMode.DLM_OnlineDoc);
    } else {
        DoSetOADocLandMode(doc, EnumDocLandMode.DLM_LocalDoc);
    }

    // if (GetParamsValue(params, constStrEnum.templateDataUrl)) {
    //     GetServerTemplateData(doc, params[constStrEnum.templateDataUrl]);
    // }

    // if (GetParamsValue(params, constStrEnum.insertFileUrl)) {
    //     InsertRedHeadDoc(doc);
    // }

    // var l_NofityURL = GetParamsValue(params, constStrEnum.notifyUrl);
    // if (l_NofityURL) {
    //     l_NofityURL = l_NofityURL.replace("{?}", "1"); //约定：参数为1则代码打开状态
    //     NotifyToServer(l_NofityURL);
    // }
    //重新设置工具条按钮的显示状态
    // pDoResetRibbonGroups();
    // 触发切换窗口事件
    OnWindowActivate();
    // 把WPS对象置前
    wps.WpsApplication().Activate();
    return doc;
}


/**
 * 作用：打开文档处理的各种过程，包含：打开带密码的文档，保护方式打开文档，修订方式打开文档等种种情况
 * params	Object	OA Web端传来的请求JSON字符串，具体参数说明看下面数据
 * TempLocalFile : 字符串 先把文档从OA系统下载并保存在Temp临时目录，这个参数指已经下载下来的本地文档地址
 * ----------------------以下是OA参数的一些具体规范名称
 * docId	String	文档ID
 * uploadPath	String	保存文档接口
 * fileName	String	获取服务器文档接口（不传即为新建空文档）
 * suffix	String	".pdf|.uot"，可传多个，用“|”分割，保存时会按照所传的值转成对应的格式文档并上传
 * userName	String	用于更改显示修改人的用户名
 * strBookmarkDataPath	string	书签列表 (可不传，可以在OA助手config.js中配置)
 * templatePath	string	模板列表 (可不传，可以在OA助手config.js中配置)
 * buttonGroups	string	自定义按钮组 （可不传，不传显示所有按钮）
 * revisionCtrl	String	痕迹控制 ，不传正常打开
 *      bOpenRevision	String	true(打开)false(关闭)修订
 *      bShowRevision	String	true(显示)/false(关闭)痕迹
 * openType	String	文档打开方式 ，不传正常打开
 *      protectType	String	文档保护类型，-1：不启用保护模式，0：只允许对现有内容进行修订，1：只允许添加批注，2：只允许修改窗体域，3：只读
 *      password	String密码
 */
function pDoOpenOADocProcess(params, TempLocalFile) {
    let l_ProtectType = -1; //默认文档保护类型 -1 为不启用保护
    let l_ProtectPassword = ""; //默认文档密码为空

    let l_strDocPassword = ""; //打开文档密码参数  
    let l_bOpenRevision = false; //初始化关闭修订模式
    let l_bShowRevision = false; //初始化不显示修订气泡样式

    for (let key in params) {
        switch (key.toUpperCase()) //
        {
            case "userName".toUpperCase(): //修改当前文档用户名
                wps.WpsApplication().UserName = params[key];
                wps.PluginStorage.setItem("userName", params[key]);
                break;
            case "openType".toUpperCase():
                l_ProtectType = params[key].protectType; //获取OA传来的文档保护类型
                l_ProtectPassword = params[key].password; //获取OA传来的保护模式下的文档密码
                break;
            case "revisionCtrl".toUpperCase(): //限制修订状态
                l_bOpenRevision = params[key].bOpenRevision;
                l_bShowRevision = params[key].bShowRevision;
                break;
            case "buttonGroups".toUpperCase(): //按钮组合
                break;
            case 'appcode'.toUpperCase(): //appcode
                wps.PluginStorage.setItem("appcode", params[key]);
                break;
            case 'key'.toUpperCase(): //appcode
                wps.PluginStorage.setItem("nccBaseDataKey", params[key]);
                break;
            case "docPassword".toUpperCase(): //传入打开文件的密码
                l_strDocPassword = params[key].docPassword;
                break;
        }

    }

    let l_Doc;
    // Open方法的参数说明如下
    //Function Open(FileName, [ConfirmConversions], [ReadOnly], [AddToRecentFiles], 
    //  [PasswordDocument], [PasswordTemplate], [Revert], [WritePasswordDocument],
    //  [WritePasswordTemplate], [Format], [Encoding], [Visible], 
    //  [OpenAndRepair], [DocumentDirection], [NoEncodingDialog], [XMLTransform]) As Document
    l_Doc = wps.WpsApplication().Documents.Open(TempLocalFile, false, false, false, l_strDocPassword);
    
    console.log('1111111111111111111')
    console.log(l_Doc.DocID)
    wps.PluginStorage.setItem(`${l_Doc.DocID}_l_bOpenRevision`, l_bOpenRevision)
    // //设置文档修订状态
    DoOADocOpenRevision(l_Doc, l_bOpenRevision, l_bShowRevision);

    // //打开文档后，根据保护类型设置文档保护
    // if (l_ProtectType > -1) // -1 :不设置文档保护 
    //     SetOADocProtect(l_Doc, l_ProtectType, l_ProtectPassword);
    return l_Doc;
}
function DoOADocOpenRevision(doc,a,b){
    if(!a && !b){ // 都为false则不显示
        wps.PluginStorage.setItem("paneFlag",false);
        wps.PluginStorage.setItem("SaveFlag",false);
        wps.ribbonUI.InvalidateControl("btnShowTaskPane");
        wps.ribbonUI.InvalidateControl("btnSaveDoc");
    } else {
        wps.PluginStorage.setItem("paneFlag",true);
        wps.PluginStorage.setItem("SaveFlag",true);
        wps.ribbonUI.InvalidateControl("btnShowTaskPane");
        wps.ribbonUI.InvalidateControl("btnSaveDoc");
    }
}
/**
 * 打开服务器上的文件
 * @param {*} fileUrl 文件url路径
 */
function OpenFile(params) {
    var l_strFileUrl = params.fileName; //来自OA网页端的OA文件下载路径
    var doc;
    var l_IsOnlineDoc = false; //默认打开的是不落地文档
    window.pk_org = params.pk_org || '';
    window.RptName = params.RptName;
    if (l_strFileUrl) {
        if (l_strFileUrl.split(':')[0] === "http") { // 网络文档
            DownloadFile("/nccloud/hr/login/InternalAction.do",params,function(path) {
                console.log(path)
                if (path == "") {
                    toast({
                        color: 'info',
                        content: "从服务端下载路径：" + l_strFileUrl + "\n" + "获取文件下载失败！"
                    })
                    // alert("从服务端下载路径：" + l_strFileUrl + "\n" + "获取文件下载失败！");
                    return null;
                }

                doc = pDoOpenOADocProcess(params, path);
                pOpenFile(doc, params, l_IsOnlineDoc);
            });
            return;
        } else { //本地文档
            doc = pDoOpenOADocProcess(params, l_strFileUrl);
            if (doc){
                let FileName = wps.Env.GetTempPath() + "/" + doc.Name
                doc.SaveAs2(FileName, undefined, undefined, undefined, false);
            }
        }
           
    } else {
        //fileURL 如果为空，则按新建OA本地文件处理    
        // NewFile(params);
    }
    //如果打开pdf等其他非Office文档，则doc对象为空
    if (!doc) {
        return null;
    }

    pOpenFile(doc, params, l_IsOnlineDoc);
}
///打开来自OA端传递来的文档
function OpenDoc(OaParams) {
    if (OaParams.fileName == "") {
        // NewFile(OaParams);
    } else {
        //OA传来下载文件的URL地址，调用openFile 方法打开
        OpenFile(OaParams);
    }
}
/**
 * 参数：
 * doc : 当前OA文档的Document对象
 * DocLandMode ： 落地模式设置
 */
function DoSetOADocLandMode(doc, DocLandMode) {
    if (!doc) return;
    var l_Param = wps.PluginStorage.getItem(doc.DocID);
    var l_objParam = JSON.parse(l_Param);
    //增加属性，或设置
    l_objParam.OADocLandMode = DocLandMode; //设置OA文档的落地标志

    var l_p = JSON.stringify(l_objParam);
    //将OA文档落地模式标志存入系统变量对象保存

    wps.PluginStorage.setItem(doc.DocID, l_p);

}
//Office文件打开后，设置该文件属性：从服务端来的OA文件
function pSetOADocumentFlag(doc, params) {
    if (!doc) {
        return; //
    }

    var l_Param = params;
    l_Param.isOA = EnumOAFlag.DocFromOA; //设置OA打开文档的标志

    l_Param.SourcePath = doc.FullName; //保存OA的原始文件路径，用于保存时分析，是否进行了另存为操作
    //console.log(l_Param.SourcePath);

    if (doc) {
        var l_p = JSON.stringify(l_Param);
        //将OA文档标志存入系统变量对象保存
        wps.PluginStorage.setItem(doc.DocID, l_p);
    }
}
/**
 *  作用：根据当前活动文档的情况判断，当前文档适用的系统参数，例如：当前文档对应的用户名称等
 */
 function SetCurrDocEnvProp(doc) {
    if (!doc) return;
    var l_bIsOADoc = false;
    l_bIsOADoc = pCheckIfOADoc(doc);

    //如果是OA文件，则按OA传来的用户名设置WPS   OA助手WPS用户名设置按钮冲突
    if (l_bIsOADoc == true) {
        var l_userName = GetDocParamsValue(doc, constStrEnum.userName);
        if (l_userName != "") {
            wps.WpsApplication().UserName = l_userName;
            return;
        }
    }
    //如果是非OA文件或者参数的值是空值，则按WPS安装默认用户名设置
    wps.WpsApplication().UserName = wps.PluginStorage.getItem(constStrEnum.WPSInitUserName);
}
//切换窗口时触发的事件
function OnWindowActivate() {
    var l_doc = wps.WpsApplication().ActiveDocument;
    console.log('切换窗口', l_doc)
    window.currentDocId = l_doc.DocID;
    wps.PluginStorage.setItem("currentDocId",window.currentDocId)
    let tsId = wps.PluginStorage.getItem("taskpane_id")
    if(tsId) {
        let tskpane = wps.GetTaskPane(tsId)
        tskpane.Visible = false;
        // if(taskpane.Visible) {
        //     tskpane.Navigate(Util.GetUrlPath() + "taskpane"+"?ts="+new Date().getTime())
        // }
        // tskpane.Delete()
    }

    // SetCurrDocEnvProp(l_doc); // 设置当前文档对应的用户名
    // showOATab(); // 根据文件是否为OA文件来显示OA菜单再进行刷新按钮
    setTimeout(activeTab(l_doc), 500); // 激活页面必须要页签显示出来，所以做1秒延迟
    return;
}
function activeTab(l_doc) {
    //启动WPS程序后，默认显示的工具栏选项卡为ribbon.xml中某一tab
    if (wps.ribbonUI)
        wps.ribbonUI.ActivateTab('wpsAddinTab');
        DoOADocOpenRevision(l_doc, wps.PluginStorage.getItem(`${l_doc.DocID}_l_bOpenRevision`), wps.PluginStorage.getItem(`${l_doc.DocID}_l_bOpenRevision`))
}
const dispatcher = (info)=>{
    console.log("打开时第一个调用这个函数！")
    // 绑定事件
    wps.ApiEvent.AddApiEventListener("WindowActivate", OnWindowActivate); // 切换窗口时的事件
    wps.ApiEvent.AddApiEventListener('DocumentBeforeClose', OnDocumentBeforeClose);
    wps.ApiEvent.AddApiEventListener("DocumentAfterClose", OnDocumentAfterClose);
    console.log('绑定成功')
    var funcs = info.funcs;
    console.log("可以找到对应的接口名。。。。",info)
    //执行web页面传递的方法
    setTimeout(function(){
        for (var index = 0; index < funcs.length; index++) {
            // testFuncs=funcs;
            var func = funcs[index];
            for (var key in func) {
                if (key === "OpenDoc") { // OpenDoc 属于普通的打开文档的操作方式，文档落地操作

                    OpenDoc(func[key]); //进入打开文档处理函数
                } else if (key === "OnlineEditDoc") { //在线方式打开文档，属于文档不落地的方式打开
                    // OnlineEditDoc(func[key]);
                }else if(key === "custormerData"){
                    // resoleData(dispatch,func[key])
                    setTimeout(() => {
                        window.allData = func[key].allData
                        openIndexDB(func[key].allData);
                        // localStorage.setItem("allData",JSON.stringify(func[key].allData))
                        console.log("开发者自定义的所有数据！！",func[key])
                    }, 1200)
                }
            }
        }
    },1000)
    return {message:"ok", app:wps.WpsApplication().Name}
    
}
const openIndexDB = (allData)=>{
    let key = allData.pk_rpt_def
    let request = window.indexedDB.open('wps',1);
    let db;
    wps.PluginStorage.setItem(window.currentDocId + "condition", JSON.stringify(allData['condition']));
    // window.condition = allData['condition']
    request.onerror = function (e) {
        console.log("wps数据库打开失败");
        console.log('失败原因：', e)
        // 失败的时候存PluginStorage 南航专业版无法使用localStorage
        try {
            if(window.currentDocId) {
                // 切换wps tab的原因 使用DocID作为key存储
                console.log('存储', window.currentDocId)
                wps.PluginStorage.setItem(window.currentDocId,JSON.stringify(allData))
            }

        } catch (e) {
            console.error('PluginStorage内存满，清理内存！请重新打开wps')
            if (e.code === QUOTA_EXCEEDED_ERR_CODE) {
                wps.PluginStorage.clear();
                wps.PluginStorage.setItem(window.currentDocId,JSON.stringify(allData))
            }
        }
         // 建立主键表 只存在唯一的值！
         if(allData.pk_conmodel){
            // window.pk_conmodel = key
            wps.PluginStorage.setItem(window.currentDocId + 'pk_conmodel', key)
        }
        wps.PluginStorage.setItem(window.currentDocId + 'pk_rpt_def', key)
        // window.pk_rpt_def = key
        wps.PluginStorage.setItem('PluginStorage',true)
        
    }
    request.onupgradeneeded = function(event) {
        console.log('创建数据库表单数据')
        db = event.target.result;
        let objectStore
        // 建立taskpane 数据联查表
        if(!db.objectStoreNames.contains('taskpane')){
            objectStore = db.createObjectStore('taskpane', { keyPath: 'id' });
            objectStore.createIndex('allData', 'allData', { unique: true });
            // 切换wps tab的原因 使用DocID作为key存储
            console.log(window.currentDocId)
            objectStore.put({id:window.currentDocId, allData: allData});
            wps.PluginStorage.setItem('PluginStorage',false)
        }
        // // 建立主键表 只存在唯一的值！
        // if(allData.pk_conmodel){
        //     // window.pk_conmodel = key
        //     wps.PluginStorage.setItem(window.currentDocId + 'pk_conmodel', key)
        // }
        // // window.pk_rpt_def = key
        // wps.PluginStorage.setItem(window.currentDocId + 'pk_rpt_def', key)
    }
    request.onsuccess = function(e){
        console.log('打开数据库成功！')
        db = request.result;
        if(allData.pk_conmodel){
            wps.PluginStorage.setItem(window.currentDocId + 'pk_conmodel', key)
        }
        wps.PluginStorage.setItem(window.currentDocId + 'pk_rpt_def', key)
        add_data(db, allData)
    }
}

function add_data(db, allData) {
    var db = db;
    var tt = db.transaction(["taskpane"],"readwrite");   
    var store =  tt.objectStore("taskpane");                
    var request = store.put({id:window.currentDocId, allData: allData}); 
    request.onerror = function(e) {
        console.log("Error",e.target.error.name);
        console.log("数据添加失败...");
    }

    request.onsuccess = function(e) {
        console.log("数据添加成功...");
    }
}
function OnBtnSaveToServer() {
    // 获取当前文档对象
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (!l_doc) {
        toast({
            color: 'warning',
            content: "空文档不能保存！"
        })
        // alert("空文档不能保存！");
        return;
    }
    l_doc.Save(); //执行一次保存方法
    var l_UploadName = l_doc.Name; //默认文件名称就是当前文件编辑名称

    var l_DocPath = l_doc.FullName; // 文件所在路径
    // var condition = wps.PluginStorage.getItem("condition")
    var condition = JSON.parse(wps.PluginStorage.getItem(window.currentDocId + "condition"));
    var conditionIds = condition && condition.map((item) => {
        {return item.id}
    })
 
    let otherData ={
        appcode: wps.PluginStorage.getItem("appcode"),
        key: wps.PluginStorage.getItem("nccBaseDataKey"),
        condition: conditionIds ? conditionIds.join(',') : [],
        userName: wps.PluginStorage.getItem("userName"),
        pk_org: window.pk_org,
        internalDataFactory: 'nccloud.web.hrhi.rptdef.factory.RtfDownloadFactory'
    };  //appcode key

    try {
        //调用OA助手的上传方法
        UploadFile(l_UploadName, l_DocPath,"/nccloud/hr/login/InternalAction.do",otherData, OnUploadToServerSuccess, OnUploadToServerFail);
    } catch (err) {
        toast({
            color: 'warning',
            content: "上传文件失败！请检查系统上传参数及网络环境！"
        })
        // alert("上传文件失败！请检查系统上传参数及网络环境！");
    }
}

/**
 * 调用文件上传到OA服务端时，
 * @param {*} resp 
 */
function OnUploadToServerSuccess(resp) {
    console.log("成功上传服务端后的回调：" + resp)
    // alert()
    var l_doc = wps.WpsApplication().ActiveDocument;
    if (wps.confirm("文件上传成功！继续编辑请确认，取消关闭文档。") == false) {
        if (l_doc) {
            console.log("OnUploadToServerSuccess: before Close");
            // 清除顶部的设计报表 待考虑

            // 如果存在pluginStorage 删除了
            let key = l_doc.DocID;
            let data = wps.PluginStorage.getItem(key)
            if(data) wps.PluginStorage.removeItem(key);
            wps.PluginStorage.removeItem(key + 'pk_rpt_def')
            wps.PluginStorage.removeItem(key + 'pk_conmodel')
            wps.PluginStorage.removeItem(key + 'condition')
            l_doc.Close(-1); //保存文档后关闭
            var fileName = window.RptName + '.rtf'
            // Administrator
            var path = wps.Env.GetHomePath()+"/Downloads"+"/"+fileName
            if(wps.FileSystem.Exists(path)) wps.FileSystem.Remove(path)
            console.log("OnUploadToServerSuccess: after Close");
        }
}

    // var l_showConfirm = wps.PluginStorage.getItem(constStrEnum.Save2OAShowConfirm);
    // if (l_showConfirm) {
    //     if (wps.confirm("文件上传成功！继续编辑请确认，取消关闭文档。") == false) {
    //         if (l_doc) {
    //             console.log("OnUploadToServerSuccess: before Close");
    //             l_doc.Close(-1); //保存文档后关闭
    //             console.log("OnUploadToServerSuccess: after Close");
    //         }
    //     }
    // }
}

function OnUploadToServerFail(resp) {
    toast({
        color: 'warning',
        content: '文件上传失败！'
    })
    // alert("文件上传失败！");
}

const ribbon = {
    //这个函数在整个wps加载项中是第一个执行的
    OnAddinLoad: function(ribbonUI) {
        if (typeof (wps.ribbonUI) != "object") {
            wps.ribbonUI = ribbonUI
        }

        if (typeof (wps.Enum) != "object") { // 如果没有内置枚举值
            wps.Enum = Util.WPS_Enum
        }

        // //这几个导出函数是给外部业务系统调用的
        // window.openOfficeFileFromSystemDemo = SystemDemo.openOfficeFileFromSystemDemo
        // window.InvokeFromSystemDemo = SystemDemo.InvokeFromSystemDemo

        wps.PluginStorage.setItem("paneFlag", true) //往PluginStorage中设置一个标记，用于控制两个按钮的置灰
        wps.PluginStorage.setItem("SaveFlag", true) //往PluginStorage中设置一个标记，用于控制ApiEvent的按钮label
        return true
    },

    OnAction: function(control) {
        const eleId = control.Id
        switch (eleId) {
            case "btnShowTaskPane":
                {
                    let tsId = wps.PluginStorage.getItem("taskpane_id")
                    console.log('将要打开wps的任务窗格',tsId)
                    // let key = window.pk_rpt_def;
                    // wps.PluginStorage.setItem("pk_rpt_def",key)
                    if (!tsId) {
                        // 将taskpane的路由地址拿到获取这个页面创建
                        let tskpane = wps.CreateTaskPane(Util.GetUrlPath() + "taskpane")
                        let id = tskpane.ID
                        wps.PluginStorage.setItem("taskpane_id", id)
                        tskpane.Visible = true
                        tskpane.Height = 800;
                        tskpane.Width = 500
                    } else {
                        let tskpane = wps.GetTaskPane(tsId)
                        tskpane.Visible = !tskpane.Visible
                        if(tskpane.Visible) {
                            tskpane.Navigate(Util.GetUrlPath() + "taskpane"+"?ts="+new Date().getTime())
                        }
                    }
                }
                break
            case "btnSaveDoc":
                {
                    // console.log("当前wps可以获取的路径！",wps.Env.GetHomePath(), wps.Env.GetAppDataPath(), wps.Env.GetDesktopDpi())
                    // window.top.startAjax("/nccloud/hr/login/InternalAction.do")
                    // typeof window.top.startAjax === 'function' && window.top.startAjax(url);
                    console.log('将当前所有保存好的数据都传递回给ncc服务')
                    OnBtnSaveToServer()
                }
                break
            default:
                break
        }
        return true
    },

    GetImage: function (control) {
        const eleId = control.Id
        switch (eleId) {
            case "btnShowTaskPane":
                return "images/3.svg"
            case "btnSaveDoc":
                return "images/2.svg"
            default:
        }
        return "images/newFromTemp.svg"
    },

    OnGetEnabled: function (control) {
        const eleId = control.Id
        switch (eleId) {
            case "btnSaveDoc":
                // return true
            // case "btnShowDialog":
                {
                    let bFlag = wps.PluginStorage.getItem("SaveFlag")
                    console.log('ccc',bFlag)
                    return bFlag
                }
            case "btnShowTaskPane":
                {
                    // return true
                    let bFlag = wps.PluginStorage.getItem("paneFlag")
                    console.log('ddd',bFlag)
                    return bFlag
                }
            default:
                break
        }
        return true
    },

    OnGetVisible: function (control) {
        const eleId = control.Id
        console.log(eleId)
        return true
    },

    OnGetLabel: function (control) {
        const eleId = control.Id
        switch (eleId) {
            case "btnShowTaskPane":
                {
                    let bFlag = wps.PluginStorage.getItem("paneFlag")
                    return bFlag ? "按钮Disable" : "按钮Enable"
                }
            case "btnSaveDoc":
                {
                    let bFlag = wps.PluginStorage.getItem("SaveFlag")
                    return bFlag ? "按钮Disable" : "按钮Enable"
                }    
            default:
                break;
        }
        return ""
    },

    OnNewDocumentApiEvent:function(doc){
        toast({
            color: 'info',
            content: "新建文件事件响应，取文件名: " + doc.Name
        })
        // alert("新建文件事件响应，取文件名: " + doc.Name)
    }

}

export {
    dispatcher,
    ribbon
} ;